package action

import (
	"../encode"
	"../global"
	"../model"
	"github.com/dxvgef/token"
	"github.com/go-pg/pg"
	"github.com/labstack/echo"
	"strconv"
	"strings"
	"time"
)

type Admin struct{}

//获取单个管理员的资料
func (*Admin) Show(ctx echo.Context) (err error) {
	response := make(map[string]interface{})
	response["error"] = ""

	if ctx.Param("admin_id") == "" {
		response["error"] = "缺少参数admin_id"
	}
	admin_id, err := strconv.ParseInt(ctx.Param("admin_id"), 0, 64)
	if err != nil {
		global.Logger.Error("admin_id数据类型转换出错：" + err.Error())
		response["error"] = "系统错误"
		return ctx.JSON(500, response)
	}
	var Model model.AdminModel
	res, err := Model.GetAdmin(&model.Admin{ID: admin_id}, []string{"id", "email", "mobile", "name"}, &model.ListParams{Limit: 1})
	if err != nil {
		if err == pg.ErrNoRows {
			global.Logger.Error("管理员不存在：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		} else {
			global.Logger.Error("查询管理员出错：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		}
	}

	if len(res) == 0 || res[0].ID == 0 {
		response["data"] = "管理员不存在"
		return ctx.JSON(200, response)
	}

	response["data"] = res[0]
	return ctx.JSON(200, response)
}

//管理员列表首页
func (*Admin) Index(ctx echo.Context) (err error) {
	response := make(map[string]interface{})
	response["error"] = ""

	var Model model.AdminModel
	res, err := Model.GetAdmin(&model.Admin{}, []string{"id", "email", "mobile", "name"}, &model.ListParams{})
	if err != nil {
		if err == pg.ErrNoRows {
			global.Logger.Error("管理员不存在：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		} else {
			global.Logger.Error("查询管理员出错：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		}
	}

	if len(res) == 0 {
		response["data"] = ""
	} else {
		response["data"] = res
	}

	return ctx.JSON(200, response)
}

//修改管理员资料
func (*Admin) Edit(ctx echo.Context) (err error) {
	response := make(map[string]interface{})
	response["error"] = ""

	if ctx.Param("admin_id") == "" {
		response["error"] = "缺少参数admin_id"
		return ctx.JSON(200, response)
	}

	admin_id, err := strconv.ParseInt(ctx.Param("admin_id"), 10, 64)
	if err != nil {
		global.Logger.Error("admin_id数据类型转换失败：" + err.Error())
		response["error"] = "系统错误"
		return ctx.JSON(500, response)
	}
	var AdminModel model.AdminModel
	res, err := AdminModel.GetAdmin(&model.Admin{ID: admin_id}, []string{"id"}, &model.ListParams{Limit: 1})
	if err != nil {
		if err == pg.ErrNoRows {
			global.Logger.Error("管理员不存在：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		} else {
			global.Logger.Error("查询管理员出错：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		}
	}

	if len(res) == 0 || res[0].ID == 0 {
		response["error"] = "管理员不存在"
		return ctx.JSON(200, response)
	}

	var query model.Admin
	query.ID = res[0].ID
	if ctx.FormValue("name") != "" {
		query.Name = ctx.FormValue("name")
	}
	if ctx.FormValue("mobile") != "" {
		query.Mobile = ctx.FormValue("mobile")
	}
	if ctx.FormValue("email") != "" {
		query.Email = ctx.FormValue("email")
	}
	if ctx.FormValue("password") != "" {
		if len(ctx.FormValue("password")) < 6 {
			response["error"] = "密码不能少于6个字符"
			return ctx.JSON(200, response)
		}
		query.Password = ctx.FormValue("password")
	}

	if query.Email != res[0].Email {
		result, err := AdminModel.GetAdmin(&model.Admin{Email: query.Email}, []string{"id"}, &model.ListParams{Limit: 1})
		if err != nil {
			if err == pg.ErrNoRows {
				global.Logger.Error("管理员不存在：" + err.Error())
				response["error"] = "系统错误"
				return ctx.JSON(500, response)
			} else {
				global.Logger.Error("查询管理员出错：" + err.Error())
				response["error"] = "系统错误"
				return ctx.JSON(500, response)
			}
		}
		if len(result) != 0 {
			response["error"] = "邮箱已被注册"
			return ctx.JSON(200, response)
		}
	}

	err = AdminModel.EditAdmin(&query)
	if err != nil {
		global.Logger.Error("修改用户出错：" + err.Error())
		response["error"] = "系统错误"
		return ctx.JSON(500, response)
	}

	return ctx.JSON(200, response)
}

//删除管理员
func (*Admin) Delete(ctx echo.Context) (err error) {
	response := make(map[string]interface{})
	response["error"] = ""

	if ctx.Param("admin_ids") == "" {
		response["error"] = "缺少参数admin_ids"
		return ctx.JSON(200, response)
	}

	var deleteIDs []int64
	var stringIDs []string
	ids := ctx.Param("admin_ids")
	stringIDs = strings.Split(ids, ",")
	for _, v := range stringIDs {
		id, err := strconv.ParseInt(v, 10, 64)
		if err != nil {
			global.Logger.Error("admin_id数据类型转换出错")
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		}
		deleteIDs = append(deleteIDs, id)
	}
	var AdminModel model.AdminModel
	var admin_ids []model.Admin
	err = global.DB.Model(&admin_ids).Column("id").WhereIn("id IN (?)", pg.In(deleteIDs)).Select()
	if err != nil {
		global.Logger.Error("查找管理员ID出错：" + err.Error())
		response["error"] = "系统错误"
		return ctx.String(500, err.Error())
	}
	if len(admin_ids) != len(deleteIDs) {
		response["error"] = "参数中含有不存在的管理员ID"
		return ctx.JSON(200, response)
	}

	//调用模型删除管理员
	err = AdminModel.DelAdmin(deleteIDs)
	if err != nil {
		global.Logger.Error("删除管理员失败：" + err.Error())
		response["error"] = "系统错误"
		return ctx.JSON(500, response)
	}
	return ctx.JSON(200, response)

}

//注册管理员
func (*Admin) Register(ctx echo.Context) (err error) {
	response := make(map[string]interface{})
	response["error"] = ""

	if ctx.FormValue("name") == "" {
		response["error"] = "请填写用户名"
		return ctx.JSON(200, response)
	}
	if ctx.FormValue("email") == "" {
		response["error"] = "请填写邮箱"
		return ctx.JSON(200, response)
	}
	if ctx.FormValue("password") == "" || len(ctx.FormValue("password")) < 6 {
		response["error"] = "密码不能为空，且至少需要6位数"
		return ctx.JSON(200, response)
	}
	if ctx.FormValue("mobile") == "" {
		response["error"] = "手机号不能为空"
		return ctx.JSON(200, response)
	}

	var Model model.AdminModel
	var query model.Admin
	ID := global.IDNode.Generate()
	query.ID = ID.Int64()
	query.Name = ctx.FormValue("name")
	query.Email = ctx.FormValue("email")
	query.Mobile = ctx.FormValue("mobile")
	query.Password = ctx.FormValue("password")

	//根据邮箱查找用户，如果存在，则说明邮箱已注册，直接返回
	res, err := Model.GetAdmin(&model.Admin{Email: query.Email}, []string{"id"}, &model.ListParams{Limit: 1})
	if err != nil {
		if err == pg.ErrNoRows {
			global.Logger.Error("管理员不存在：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		} else {
			global.Logger.Error("查询管理员出错：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		}
	}

	if len(res) != 0 {
		response["error"] = "该邮箱已被注册"
		return ctx.JSON(200, response)
	}

	err = Model.RegAdmin(&query)
	if err != nil {
		global.Logger.Error("创建管理员出错：" + err.Error())
		response["error"] = "系统错误"
		return ctx.JSON(500, response)
	}
	return ctx.JSON(200, response)
}

//管理员登录
func (*Admin) Login(ctx echo.Context) (err error) {
	response := make(map[string]interface{})
	response["error"] = ""
	if ctx.FormValue("account") == "" {
		response["error"] = "邮箱不能为空"
		return ctx.JSON(200, response)
	}
	var query model.Admin
	query.Email = ctx.FormValue("account")
	var Model model.AdminModel
	res, err := Model.GetAdmin(&model.Admin{Email: query.Email}, []string{"id", "password"}, &model.ListParams{Limit: 1})
	if err != nil {
		if err == pg.ErrNoRows {
			global.Logger.Error("管理员不存在：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		} else {
			global.Logger.Error("查询管理员出错：" + err.Error())
			response["error"] = "系统错误"
			return ctx.JSON(500, response)
		}
	}

	if len(res) == 0 || res[0].ID == 0 {
		response["error"] = "管理员不存在"
		return ctx.JSON(200, response)
	}

	//对密码进行加密，比对是否正确
	password, err := encode.MD5ByStr(ctx.FormValue("password"), global.Config.Section("app").Key("passwordKey").String())
	if err != nil {
		global.Logger.Error("密码加密失败：" + err.Error())
		response["error"] = "系统错误"
		return ctx.JSON(500, response)
	}
	if password != res[0].Password {
		response["error"] = "密码不正确"
		return ctx.JSON(200, response)
	}

	return CreateToken(res[0].ID, ctx)
}

//测试，生成token
func (*Admin) Token(ctx echo.Context) error {
	var admin model.Admin
	err := global.DB.Model(&admin).Column("id").Limit(1).Select()
	if err != nil {
		return ctx.String(500, err.Error())
	}
	return CreateToken(admin.ID, ctx)
}

//创建token返回给客户端
func CreateToken(ID int64, ctx echo.Context) error {
	var claims global.TokenClaims
	response := make(map[string]interface{})
	response["error"] = ""

	claims.AdminID = ID
	claims.ClaimsAT = time.Now().Unix()
	claims.ClaimsExp = time.Now().Add(global.Config.Section("token").Key("timeout").MustDuration(7200) * time.Second).Unix()

	tokenStr, err := token.NewString(claims, global.Config.Section("token").Key("key").String())
	if err != nil {
		global.Logger.Error("生成token失败：" + err.Error())
		response["error"] = "系统错误"
		return ctx.JSON(500, response)
	}

	//组合json结构并输出给客户端
	data := make(map[string]interface{})
	data["id"] = ID
	data["token"] = tokenStr
	response["data"] = data
	return ctx.JSON(200, response)
}
